// app.js
// 注意：云服务模块的引入放在云开发初始化之后

App({
  globalData: {
    userInfo: null,
    userRole: null, // null: 未登录, member: 家庭成员, chef: 厨师
    isLoggedIn: false,
    familyInfo: null,
    dishes: [],
    cart: [],
    orders: [],
    needRefreshOrderStats: false, // 标记是否需要刷新订单统计
    showGlobalLoginModal: false // 全局登录弹框显示状态
  },

  onLaunch() {
    console.log('应用启动')
    
    // 初始化云开发
    this.initCloud()
    
    // 初始化默认数据
    this.initDefaultData()
    
    // 初始化事件总线
    this.initEventBus()
    
    // 初始化页面管理
    this.globalData.currentPages = []
    
    // 初始化TabBar图标
    this.initTabBarIcons()
    
    // 初始化TabBar图标实时更新机制
    this.initTabBarAutoRefresh()
    
    // 检查用户登录状态
    this.checkUserLogin().then(() => {
      console.log('用户登录状态检查完成')
      
      // 异步同步服务数据
      this.syncDishesData().then(() => {
        console.log('服务数据同步完成')
      }).catch(error => {
        console.error('服务数据同步失败:', error)
      })
    }).catch(error => {
      console.error('检查用户登录状态失败:', error)
      
      // 即使登录检查失败，也尝试同步服务数据
      this.syncDishesData().then(() => {
        console.log('服务数据同步完成')
      }).catch(error => {
        console.error('服务数据同步失败:', error)
      })
    })
    
    console.log('应用启动完成')
  },

  onShow() {
    // 小程序显示时执行
    console.log('小程序显示')
    
    // 重新启动TabBar自动刷新
    if (!this.globalData.tabBarRefreshTimer) {
      this.initTabBarAutoRefresh()
    }
    
    // 立即检查一次TabBar更新
    setTimeout(() => {
      this.checkTabBarIconUpdates()
    }, 1000)
  },

  onHide() {
    // 小程序隐藏时执行
    console.log('小程序隐藏')
    
    // 停止TabBar自动刷新以节省资源
    this.stopTabBarAutoRefresh()
  },

  // 注册页面实例
  registerPage(pageInstance) {
    if (!this.globalData.currentPages) {
      this.globalData.currentPages = []
    }
    
    // 检查是否已经注册
    const existingIndex = this.globalData.currentPages.findIndex(page => page === pageInstance)
    if (existingIndex === -1) {
      this.globalData.currentPages.push(pageInstance)
      console.log('页面已注册，当前注册页面数:', this.globalData.currentPages.length)
    }
  },

  // 注销页面实例
  unregisterPage(pageInstance) {
    if (this.globalData.currentPages) {
      const index = this.globalData.currentPages.findIndex(page => page === pageInstance)
      if (index !== -1) {
        this.globalData.currentPages.splice(index, 1)
        console.log('页面已注销，当前注册页面数:', this.globalData.currentPages.length)
      }
    }
  },

  // 初始化微信云开发
  initCloud() {
    if (!wx.cloud) {
      console.error('请使用 2.2.3 或以上的基础库以使用云能力')
      return
    }
    
    wx.cloud.init({
      env: 'cloudbase-9ghiew2sb390831b',
      traceUser: true
    })
    
    console.log('微信云开发初始化成功')
    
    // 检查云数据库权限
    this.checkCloudPermissions()
  },

  // 检查云数据库权限
  async checkCloudPermissions() {
    try {
      console.log('检查云数据库权限...')
      
      const { dishService } = require('./utils/cloud.js')
      
      // 尝试读取服务数据
      const readResult = await dishService.getDishesByFamily()
      if (readResult.success) {
        console.log('✅ 读取权限正常')
      } else {
        console.error('❌ 读取权限异常:', readResult.error)
      }
      
      // 尝试创建一个测试服务来检查写入权限
      const testDish = {
        name: '权限测试服务',
        desc: '用于测试云数据库权限',
        category: '测试',
        price: 0,
        available: false
      }
      
      console.log('创建测试服务:', testDish)
      const writeResult = await dishService.createDish(testDish)
      if (writeResult.success) {
        console.log('✅ 写入权限正常')
        
        // 删除测试服务
        const deleteResult = await dishService.deleteDish(writeResult.data._id)
        if (deleteResult.success) {
          console.log('✅ 删除权限正常')
        } else {
          console.error('❌ 删除权限异常:', deleteResult.error)
        }
      } else {
        console.error('❌ 写入权限异常:', writeResult.error)
      }
      
    } catch (error) {
      console.error('权限检查失败:', error)
    }
  },

  // 检查用户登录状态
  async checkUserLogin() {
    // 从本地存储检查登录状态
    const isLoggedIn = wx.getStorageSync('isLoggedIn')
    const userInfo = wx.getStorageSync('userInfo')
    const userRole = wx.getStorageSync('userRole')
    const familyInfo = wx.getStorageSync('familyInfo')
    
    console.log('=== 登录状态检查 ===')
    console.log('本地存储 - isLoggedIn:', isLoggedIn)
    console.log('本地存储 - userInfo:', userInfo)
    console.log('本地存储 - userRole:', userRole)
    console.log('本地存储 - familyInfo:', familyInfo)
    
    if (isLoggedIn && userInfo && userRole) {
      // 恢复登录状态
      this.globalData.isLoggedIn = true
      this.globalData.userInfo = userInfo
      this.globalData.userRole = userRole
      
      console.log('登录状态恢复成功')
      console.log('全局数据 - userInfo._id:', this.globalData.userInfo._id)
      
      // 恢复家庭信息
      await this.restoreFamilyInfo(userInfo)
      
      // 从云数据库加载服务数据
      await this.loadDishesFromCloud()
      
      // 从云数据库加载订单数据
      await this.loadOrdersFromCloud()
      
      // 从云数据库获取用户最新积分
      await this.loadUserPointsFromCloud()
      
      console.log('用户已登录，角色：', userRole)
    } else {
      console.log('用户未登录 - 允许浏览功能')
      // 设置默认角色为 member，但不强制登录
      this.globalData.userRole = 'member'
      this.globalData.isLoggedIn = false
      this.globalData.userInfo = null
      
      // 即使未登录，也尝试加载服务数据供浏览
      await this.loadDishesFromCloud()
    }
    console.log('=== 登录状态检查结束 ===')
  },

  // 从云数据库加载服务数据
  async loadDishesFromCloud() {
    try {
      // 动态引入云服务，确保云开发已初始化
      const { dishService } = require('./utils/cloud.js')
      
      // 使用固定的家庭ID加载服务
      const result = await dishService.getDishesByFamily('xiaoweichufang')
      if (result.success) {
        this.globalData.dishes = result.data
        console.log('从云数据库加载服务成功，共', result.data.length, '道菜')
      } else {
        console.error('从云数据库加载服务失败')
        this.globalData.dishes = []
      }
    } catch (error) {
      console.error('加载服务数据失败:', error)
      this.globalData.dishes = []
    }
  },

  // 从云数据库加载订单数据
  async loadOrdersFromCloud() {
    try {
      // 动态引入云服务，确保云开发已初始化
      const { orderService } = require('./utils/cloud.js')
      
      // 需要传入familyId来获取家庭的所有订单
      if (!this.globalData.userInfo || !this.globalData.userInfo._id) {
        console.error('无法加载订单：用户信息缺失')
        this.globalData.orders = []
        return
      }
      
      // 使用固定的家庭ID，厨师可以看到所有家庭成员的订单
      const familyId = 'xiaoweichufang'
      const result = await orderService.getFamilyOrders(familyId)
      if (result.success) {
        this.globalData.orders = result.data
        console.log(`从云数据库加载家庭 ${familyId} 的所有订单成功，共 ${result.data.length} 个订单`)
      } else {
        console.error('从云数据库加载订单失败:', result.error)
        this.globalData.orders = []
      }
    } catch (error) {
      console.error('加载订单数据失败:', error)
      this.globalData.orders = []
    }
  },

  // 刷新服务数据
  async refreshDishes() {
    await this.loadDishesFromCloud()
  },

  // 刷新订单数据
  async refreshOrders() {
    await this.loadOrdersFromCloud()
  },

  // 从云数据库加载用户积分
  async loadUserPointsFromCloud() {
    try {
      if (!this.globalData.userInfo || !this.globalData.userInfo._id) {
        console.error('无法加载用户积分：用户信息缺失')
        return
      }
      
      const { userService } = require('./utils/cloud.js')
      const userId = this.globalData.userInfo._id
      const result = await userService.getUserPoints(userId)
      
      if (result.success) {
        const points = result.data
        this.globalData.userInfo.points = points
        console.log(`从云数据库加载用户 ${userId} 的积分成功，当前积分：${points}`)
      } else {
        console.error('从云数据库加载用户积分失败:', result.error)
        // 如果获取积分失败，可能是用户没有积分字段，设置默认积分
        console.log('尝试为用户设置默认积分')
        const setResult = await userService.updateUserPoints(userId, 100, 'set')
        if (setResult.success) {
          this.globalData.userInfo.points = 100
          console.log('为用户设置默认积分成功：100')
        }
      }
    } catch (error) {
      console.error('加载用户积分数据失败:', error)
    }
  },

  // 创建默认家庭信息结构
  createDefaultFamilyInfo(familyId) {
    console.log('创建默认家庭信息结构，familyId:', familyId)
    const defaultFamilyInfo = {
      _id: familyId,
      name: '榕城会馆',
      inviteCode: 'XWC2024',
      adminId: null,
      members: [],
      createTime: new Date().toLocaleString()
    }
    
    this.globalData.familyInfo = defaultFamilyInfo
    wx.setStorageSync('familyInfo', defaultFamilyInfo)
    console.log('默认家庭信息创建成功:', defaultFamilyInfo)
  },

  // 初始化默认数据
  initDefaultData() {
    // 初始化默认服务数据
    // 本地不需要默认服务，从云数据库加载
    if (!this.globalData.dishes) {
      this.globalData.dishes = []
    }
  },

  // 同步服务数据
  async syncDishesData() {
    console.log('开始同步服务数据...')
    
    try {
      // 尝试从云数据库加载最新数据
      const { dishService } = require('./utils/cloud.js')
      // 使用固定的家庭ID查询服务
      const familyId = 'xiaoweichufang'
      const cloudResult = await dishService.getDishesByFamily(familyId)
      
      if (cloudResult.success && cloudResult.data.length > 0) {
        console.log('从云数据库加载服务数据:', cloudResult.data.length, '道菜')
        
        // 合并云数据库和本地数据
        const cloudDishes = cloudResult.data
        const localDishes = this.globalData.dishes || []
        
        // 创建服务ID映射
        const cloudDishMap = new Map()
        cloudDishes.forEach(dish => {
          const dishId = dish._id || dish.id
          cloudDishMap.set(dishId, dish)
        })
        
        // 检查本地数据中是否有云数据库已删除的服务
        const dishesToRemove = []
        localDishes.forEach(localDish => {
          const localId = localDish._id || localDish.id
          // 如果是云数据库ID格式且云数据库中不存在，标记为删除
          // 但是要排除本地临时ID（以dish_开头的）
          if (typeof localId === 'string' && localId.length > 10 && !localId.startsWith('dish_') && !cloudDishMap.has(localId)) {
            dishesToRemove.push(localId)
            console.log('发现已删除的服务:', localDish.name, localId)
          }
        })
        
        // 从本地数据中移除已删除的服务
        if (dishesToRemove.length > 0) {
          this.globalData.dishes = localDishes.filter(dish => {
            const dishId = dish._id || dish.id
            return !dishesToRemove.includes(dishId)
          })
          console.log('清理已删除的服务:', dishesToRemove.length, '道')
        }
        
        // 合并数据，云数据库数据优先
        const mergedDishes = []
        
        // 先添加云数据库中的服务
        cloudDishes.forEach(dish => {
          const dishId = dish._id || dish.id
          mergedDishes.push({
            ...dish,
            _id: dishId,
            id: dishId, // 保持向后兼容
            image: dish.image || this.getDefaultDishImage(dish.category || '大菜'),
            createTime: dish.createTime || new Date().toLocaleString(),
            updateTime: dish.updateTime || new Date().toLocaleString()
          })
        })
        
        // 更新全局数据
        this.globalData.dishes = mergedDishes
        
        console.log('云数据库同步完成，共', mergedDishes.length, '道菜')
      } else {
        console.log('云数据库无数据或加载失败，使用本地数据')
        // 使用本地数据，确保数据结构统一
        const dishes = this.globalData.dishes || []
        const processedDishes = dishes.map(dish => {
          const dishId = dish._id || dish.id
          return {
            _id: dishId,
            id: dishId, // 保持向后兼容
            name: dish.name || '',
            desc: dish.desc || '',
            category: dish.category || '大菜',
            price: dish.price || 0,
            available: dish.available !== undefined ? dish.available : true,
            image: dish.image || this.getDefaultDishImage(dish.category || '大菜'),
            createTime: dish.createTime || new Date().toLocaleString(),
            updateTime: dish.updateTime || new Date().toLocaleString()
          }
        })
        
        this.globalData.dishes = processedDishes
      }
      
      // 保存到本地存储
      wx.setStorageSync('dishes', this.globalData.dishes)
      
      // 通知所有页面服务数据已更新
      this.notifyDishesDataChanged(this.globalData.dishes)
      
      console.log('服务数据同步完成，共', this.globalData.dishes.length, '道菜')
      console.log('同步后的服务数据:', this.globalData.dishes)
      
      return this.globalData.dishes
    } catch (error) {
      console.error('服务数据同步失败:', error)
      
      // 同步失败时使用本地数据
      const dishes = this.globalData.dishes || []
      const processedDishes = dishes.map(dish => {
        const dishId = dish._id || dish.id
        return {
          _id: dishId,
          id: dishId,
          name: dish.name || '',
          desc: dish.desc || '',
          category: dish.category || '大菜',
          price: dish.price || 0,
          available: dish.available !== undefined ? dish.available : true,
          image: dish.image || this.getDefaultDishImage(dish.category || '大菜'),
          createTime: dish.createTime || new Date().toLocaleString(),
          updateTime: dish.updateTime || new Date().toLocaleString()
        }
      })
      
      this.globalData.dishes = processedDishes
      wx.setStorageSync('dishes', processedDishes)
      
      return processedDishes
    }
  },

  // 通知服务数据变化
  notifyDishesDataChanged(dishes) {
    console.log('通知服务数据变化，共', dishes.length, '道菜')
    
    // 设置全局标志，表示服务数据已更新
    this.globalData.dishesLastUpdated = Date.now()
    this.globalData.dishesDataChanged = true
    
    // 保存到本地存储，供其他页面检查
    wx.setStorageSync('dishesLastUpdated', this.globalData.dishesLastUpdated)
    wx.setStorageSync('dishesDataChanged', true)
    
    // 使用全局事件总线通知所有页面
    if (this.globalData.eventBus) {
      this.globalData.eventBus.emit('dishesDataChanged', dishes)
    }
    
    // 如果当前有页面实例，尝试直接通知
    if (this.globalData.currentPages) {
      this.globalData.currentPages.forEach(page => {
        if (page && typeof page.onDishesDataChanged === 'function') {
          try {
            page.onDishesDataChanged(dishes)
          } catch (error) {
            console.log('通知页面失败:', error)
          }
        }
      })
    }
  },

  // 初始化事件总线
  initEventBus() {
    if (!this.globalData.eventBus) {
      this.globalData.eventBus = {
        listeners: {},
        on: function(event, callback) {
          if (!this.listeners[event]) {
            this.listeners[event] = []
          }
          this.listeners[event].push(callback)
          console.log(`事件监听器已添加: ${event}, 当前监听器数量:`, this.listeners[event].length)
        },
        emit: function(event, data) {
          console.log(`事件已发送: ${event}, 监听器数量:`, this.listeners[event] ? this.listeners[event].length : 0)
          if (this.listeners[event]) {
            this.listeners[event].forEach((callback, index) => {
              try {
                console.log(`执行监听器 ${index + 1}:`, callback)
                callback(data)
              } catch (error) {
                console.log('事件回调执行失败:', error)
              }
            })
          }
        },
        off: function(event, callback) {
          if (this.listeners[event]) {
            const index = this.listeners[event].indexOf(callback)
            if (index > -1) { 
              this.listeners[event].splice(index, 1)
              console.log(`事件监听器已移除: ${event}, 剩余监听器数量:`, this.listeners[event].length)
            }
          }
        }
      }
      console.log('✅ 事件总线初始化完成')
    }
    
    // 启动全局订单状态监控器
    this.startOrderStatusMonitor()
  },

  // 启动全局订单状态监控器
  startOrderStatusMonitor() {
    // 每8秒检查一次订单状态变化
    this.globalData.orderMonitorTimer = setInterval(async () => {
      try {
        console.log('🔄 全局订单状态监控器运行中...')
        
        // 检查当前用户
        if (!this.globalData.userInfo || !this.globalData.userInfo._id) {
          console.log('用户未登录，跳过订单状态监控')
          return
        }
        
        const currentUserId = this.globalData.userInfo._id
        console.log('监控用户订单状态变化，用户ID:', currentUserId)
        
        // 从云数据库获取最新订单数据
        const { orderService } = require('./utils/cloud.js')
        const result = await orderService.getFamilyOrders('xiaoweichufang')
        
        if (result.success && result.data) {
          const cloudOrders = result.data
          const localOrders = this.globalData.orders || []
          
          // 只获取当前用户的订单
          const userOrders = cloudOrders.filter(order => order.userId === currentUserId)
          console.log(`云数据库总订单数: ${cloudOrders.length}, 当前用户订单数: ${userOrders.length}`)
          
          // 只检查当前用户的订单状态变化
          let hasChanges = false
          const changes = []
          
          userOrders.forEach(cloudOrder => {
            const localOrder = localOrders.find(local => local._id === cloudOrder._id)
            if (localOrder && localOrder.status !== cloudOrder.status) {
              hasChanges = true
              changes.push({
                orderId: cloudOrder._id,
                oldStatus: localOrder.status,
                newStatus: cloudOrder.status
              })
              
              // 更新本地订单状态
              localOrder.status = cloudOrder.status
            }
          })
          
          if (hasChanges) {
            console.log('🔄 检测到当前用户订单状态变化:', changes)
            
            // 发送状态变化事件
            if (this.globalData.eventBus) {
              this.globalData.eventBus.emit('orderStatusChanged', {
                message: '订单状态已更新',
                changes: changes,
                timestamp: Date.now()
              })
            }
          }
          
          // 只更新当前用户的订单到全局数据，而不是所有订单
          this.globalData.orders = userOrders
          console.log(`全局订单数据已更新，当前用户订单数: ${userOrders.length}`)
        }
      } catch (error) {
        console.error('全局订单状态监控器运行失败:', error)
      }
    }, 8000) // 8秒检查一次
    
    console.log('✅ 全局订单状态监控器已启动')
  },

  // 获取默认服务图片
  getDefaultDishImage(category) {
    const imageMap = {
      '大菜': '/images/dishes/hongshao_rou.jpg',
      '小菜': '/images/dishes/qingjiao_tudousi.jpg',
      '茶点': '/images/dishes/xiaomantou.jpg',
      '饮品': '/images/dishes/zicai_danhua.jpg',
      '套餐': '/images/dishes/baimifan.jpg'
    }
    
    return imageMap[category] || '/images/dishes/hongshao_rou.jpg'
  },

  // 添加服务（厨师后台使用）
  async addDish(dishData) {
    console.log('添加服务:', dishData)
    
    try {
      // 同步到云数据库（只传递用户数据，不包含系统字段）
      const { dishService } = require('./utils/cloud.js')
      const cloudResult = await dishService.createDish(dishData)
      
      if (cloudResult.success) {
        // 云数据库同步成功，获取云端返回的服务数据
        const cloudDishData = cloudResult.data;
        
        // 生成完整的服务对象
        const newDish = {
          _id: cloudDishData._id || `dish_${Date.now()}`,
          id: cloudDishData._id || Date.now(), // 保持向后兼容
          ...dishData,
          createTime: new Date().toLocaleString(),
          updateTime: new Date().toLocaleString()
        }
        
        // 添加到本地数据
        this.globalData.dishes.push(newDish)
        
        // 同步数据
        await this.syncDishesData()
        
        console.log('服务添加成功，已同步到云端:', newDish)
        return newDish
      } else {
        console.error('云数据库同步失败:', cloudResult.error)
        wx.showToast({
          title: '云端同步失败',
          icon: 'error'
        })
        return null
      }
    } catch (error) {
      console.error('添加服务失败:', error)
      wx.showToast({
        title: '添加失败',
        icon: 'error'
      })
      return null
    }
  },

  // 更新服务（厨师后台使用）
  async updateDish(dishId, updateData) {
    console.log('更新服务:', dishId, updateData)
    
    try {
      const dishes = this.globalData.dishes
      
      // 查找要更新的服务（支持多种ID格式）
      let dishIndex = -1
      
      // 先尝试直接匹配
      dishIndex = dishes.findIndex(dish => (dish._id === dishId || dish.id === dishId))
      
      if (dishIndex === -1) {
        // 如果没找到，尝试转换ID格式
        if (dishId.startsWith('dish_')) {
          // 本地ID格式，尝试转换为数字ID
          const numericId = parseInt(dishId.replace('dish_', ''))
          dishIndex = dishes.findIndex(dish => dish.id === numericId)
        } else if (typeof dishId === 'string' && dishId.length > 10) {
          // 可能是云数据库ID，尝试匹配
          dishIndex = dishes.findIndex(dish => dish._id === dishId)
        }
      }
      
      if (dishIndex !== -1) {
        const dishToUpdate = dishes[dishIndex]
        console.log('找到要更新的服务:', dishToUpdate)
        
        // 准备更新数据
        const updatedDish = {
          ...dishToUpdate,
          ...updateData,
          updateTime: new Date().toLocaleString()
        }
        
        // 获取真实的云数据库ID
        let cloudDishId = dishToUpdate._id || dishToUpdate.id
        
        // 如果是本地ID，需要先查询云数据库获取真实ID
        if (cloudDishId.toString().startsWith('dish_') || typeof cloudDishId === 'number') {
          console.log('本地ID，需要查询云数据库获取真实ID')
          
          // 尝试通过服务名称查找云数据库中的对应记录
          const { dishService } = require('./utils/cloud.js')
          const searchResult = await dishService.getDishesByFamily()
          
          if (searchResult.success) {
            const cloudDish = searchResult.data.find(dish => 
              dish.name === dishToUpdate.name && 
              dish.category === dishToUpdate.category
            )
            
            if (cloudDish) {
              cloudDishId = cloudDish._id
              console.log('找到云数据库对应记录，ID:', cloudDishId)
            } else {
              console.log('云数据库中未找到对应记录，可能已被删除')
              // 直接更新本地数据
              dishes[dishIndex] = updatedDish
              this.syncDishesData()
              console.log('本地更新成功（云数据库无对应记录）')
              return updatedDish
            }
          }
        }
        
        // 同步到云数据库
        if (cloudDishId && !cloudDishId.toString().startsWith('dish_') && typeof cloudDishId !== 'number') {
          console.log('尝试更新云数据库记录，ID:', cloudDishId)
          
          // 过滤掉系统字段，只保留用户可编辑的字段
          const allowedFields = ['name', 'desc', 'description', 'category', 'price', 'available', 'image']
          const filteredUpdateData = {}
          
          Object.keys(updateData).forEach(key => {
            if (allowedFields.includes(key)) {
              filteredUpdateData[key] = updateData[key]
            }
          })
          
          console.log('过滤后的更新数据:', filteredUpdateData)
          
          const { dishService } = require('./utils/cloud.js')
          const cloudResult = await dishService.updateDish(cloudDishId, filteredUpdateData)
          
          if (cloudResult.success) {
            // 云数据库同步成功，更新本地数据
            dishes[dishIndex] = updatedDish
            
            // 同步数据
            this.syncDishesData()
            
            console.log('服务更新成功，已同步到云端:', updatedDish)
            return updatedDish
          } else {
            console.error('云数据库同步失败:', cloudResult.error)
            
            // 检查是否是权限问题
            if (cloudResult.error && cloudResult.error.message && 
                cloudResult.error.message.includes('Write permission')) {
              wx.showToast({
                title: '权限不足，无法更新',
                icon: 'error'
              })
            } else {
              wx.showToast({
                title: '云端更新失败',
                icon: 'error'
              })
            }
            return null
          }
        } else {
          // 没有有效的云数据库ID，直接更新本地数据
          console.log('无有效云数据库ID，直接更新本地数据')
          dishes[dishIndex] = updatedDish
          this.syncDishesData()
          console.log('本地更新成功')
          return updatedDish
        }
      } else {
        console.error('服务不存在:', dishId)
        wx.showToast({
          title: '服务不存在',
          icon: 'error'
        })
        return null
      }
    } catch (error) {
      console.error('更新服务失败:', error)
      wx.showToast({
        title: '更新失败',
        icon: 'error'
      })
      return null
    }
  },

  // 删除服务（厨师后台使用）
  async deleteDish(dishId) {
    console.log('删除服务:', dishId)
    
    try {
      const dishes = this.globalData.dishes
      
      // 查找要删除的服务（支持多种ID格式）
      let dishToDelete = null
      let dishIndex = -1
      
      // 先尝试直接匹配
      dishIndex = dishes.findIndex(dish => (dish._id === dishId || dish.id === dishId))
      
      if (dishIndex === -1) {
        // 如果没找到，尝试转换ID格式
        if (dishId.startsWith('dish_')) {
          // 本地ID格式，尝试转换为数字ID
          const numericId = parseInt(dishId.replace('dish_', ''))
          dishIndex = dishes.findIndex(dish => dish.id === numericId)
        } else if (typeof dishId === 'string' && dishId.length > 10) {
          // 可能是云数据库ID，尝试匹配
          dishIndex = dishes.findIndex(dish => dish._id === dishId)
        }
      }
      
      if (dishIndex !== -1) {
        dishToDelete = dishes[dishIndex]
        console.log('找到要删除的服务:', dishToDelete)
        
        // 获取真实的云数据库ID
        let cloudDishId = dishToDelete._id || dishToDelete.id
        
        // 如果是本地ID，需要先查询云数据库获取真实ID
        if (cloudDishId.toString().startsWith('dish_') || typeof cloudDishId === 'number') {
          console.log('本地ID，需要查询云数据库获取真实ID')
          
          // 尝试通过服务名称查找云数据库中的对应记录
          const { dishService } = require('./utils/cloud.js')
          const searchResult = await dishService.getDishesByFamily()
          
          if (searchResult.success) {
            const cloudDish = searchResult.data.find(dish => 
              dish.name === dishToDelete.name && 
              dish.category === dishToDelete.category
            )
            
            if (cloudDish) {
              cloudDishId = cloudDish._id
              console.log('找到云数据库对应记录，ID:', cloudDishId)
            } else {
              console.log('云数据库中未找到对应记录，可能已被删除')
              // 直接从本地删除
              dishes.splice(dishIndex, 1)
              this.globalData.dishes = dishes
              this.syncDishesData()
              console.log('本地删除成功（云数据库无对应记录）')
              return true
            }
          }
        }
        
        // 同步到云数据库
        if (cloudDishId && !cloudDishId.toString().startsWith('dish_') && typeof cloudDishId !== 'number') {
          console.log('尝试删除云数据库记录，ID:', cloudDishId)
          
          const { dishService } = require('./utils/cloud.js')
          const cloudResult = await dishService.deleteDish(cloudDishId)
          
          if (cloudResult.success) {
            // 云数据库同步成功，从本地数据中删除
            dishes.splice(dishIndex, 1)
            this.globalData.dishes = dishes
            
            // 同步数据
            this.syncDishesData()
            
            console.log('服务删除成功，已同步到云端')
            return true
          } else {
            console.error('云数据库同步失败:', cloudResult.error)
            
            // 根据错误类型提供更友好的提示
            let errorMessage = '云端删除失败'
            if (cloudResult.error && typeof cloudResult.error === 'string') {
              if (cloudResult.error.includes('权限不足')) {
                errorMessage = '权限不足，无法删除该服务'
              } else if (cloudResult.error.includes('不存在')) {
                errorMessage = '服务不存在或已被删除'
              } else if (cloudResult.error.includes('网络')) {
                errorMessage = '网络连接失败，请重试'
              }
            } else if (cloudResult.originalError && cloudResult.originalError.message) {
              if (cloudResult.originalError.message.includes('Write permission')) {
                errorMessage = '权限不足，无法删除该服务'
              } else if (cloudResult.originalError.message.includes('not exist')) {
                errorMessage = '服务不存在或已被删除'
              }
            }
            
            wx.showToast({
              title: errorMessage,
              icon: 'error',
              duration: 3000
            })
            
            // 如果是权限问题，尝试本地删除
            if (cloudResult.error && (cloudResult.error.includes('权限不足') || 
                (cloudResult.originalError && cloudResult.originalError.message && 
                 cloudResult.originalError.message.includes('Write permission')))) {
              console.log('权限不足，尝试本地删除')
              dishes.splice(dishIndex, 1)
              this.globalData.dishes = dishes
              this.syncDishesData()
              wx.showToast({
                title: '已从本地删除，云端同步失败',
                icon: 'none',
                duration: 2000
              })
              return true
            }
            
            return false
          }
        } else {
          // 没有有效的云数据库ID，直接从本地删除
          console.log('无有效云数据库ID，直接从本地删除')
          dishes.splice(dishIndex, 1)
          this.globalData.dishes = dishes
          this.syncDishesData()
          console.log('本地删除成功')
          return true
        }
      } else {
        console.error('服务不存在:', dishId)
        wx.showToast({
          title: '服务不存在',
          icon: 'error'
        })
        return false
      }
    } catch (error) {
      console.error('删除服务失败:', error)
      wx.showToast({
        title: '删除失败',
        icon: 'error'
      })
      return false
    }
  },

  // 角色判断函数
  isChef() {
    // 优先检查用户信息中的角色字段
    if (this.globalData.userInfo && this.globalData.userInfo.role) {
      return this.globalData.userInfo.role === 'chef' || this.globalData.userInfo.role === 'admin'
    }
    // 如果没有用户信息，则检查全局角色字段
    return this.globalData.userRole === 'chef' || this.globalData.userRole === 'admin'
  },

  isMember() {
    // 优先检查用户信息中的角色字段
    if (this.globalData.userInfo && this.globalData.userInfo.role) {
      return this.globalData.userInfo.role === 'member'
    }
    // 如果没有用户信息，则检查全局角色字段
    return this.globalData.userRole === 'member'
  },

  isAdmin() {
    // 优先检查用户信息中的角色字段
    if (this.globalData.userInfo && this.globalData.userInfo.role) {
      return this.globalData.userInfo.role === 'admin'
    }
    // 如果没有用户信息，则检查全局角色字段
    return this.globalData.userRole === 'admin'
  },

  // 切换用户角色
  switchUserRole(role) {
    this.globalData.userRole = role
    wx.setStorageSync('userRole', role)
    console.log('用户角色已切换为:', role)
  },

  // 添加到购物车
  addToCart(dish, quantity = 1, note = '') {
    console.log('添加到购物车:', { dish, quantity, note })
    
    // 获取服务的唯一标识符（优先使用_id，兼容id）
    const dishId = dish._id || dish.id
    
    // 验证服务数据的完整性
    if (!dishId || !dish.name || dish.price === undefined) {
      console.error('服务数据不完整:', dish)
      console.error('缺少字段:', { 
        id: dishId, 
        name: dish.name, 
        price: dish.price 
      })
      return
    }
    
    // 统一使用_id作为标识符
    const existingItem = this.globalData.cart.find(item => (item._id || item.id) === dishId)
    
    if (existingItem) {
      existingItem.quantity += quantity
      if (note) existingItem.note = note
      console.log('更新购物车中已有服务:', existingItem)
    } else {
      const newItem = {
        ...dish,
        _id: dishId, // 确保使用_id
        quantity,
        note
      }
      this.globalData.cart.push(newItem)
      console.log('添加新服务到购物车:', newItem)
    }
    
    console.log('当前购物车:', this.globalData.cart)
  },

  // 从购物车移除
  removeFromCart(dishId, quantity = 1) {
    // 支持通过_id或id查找
    const item = this.globalData.cart.find(item => (item._id || item.id) === dishId)
    if (item) {
      if (quantity >= item.quantity) {
        // 如果移除数量大于等于购物车中的数量，完全移除
        const index = this.globalData.cart.findIndex(item => (item._id || item.id) === dishId)
        if (index > -1) {
          this.globalData.cart.splice(index, 1)
        }
      } else {
        // 否则减少数量
        item.quantity -= quantity
      }
    }
  },

  // 更新购物车数量
  updateCartQuantity(dishId, quantity) {
    const item = this.globalData.cart.find(item => (item._id || item.id) === dishId)
    if (item) {
      if (quantity <= 0) {
        this.removeFromCart(dishId)
      } else {
        item.quantity = quantity
      }
    }
  },

  // 清空购物车
  clearCart() {
    this.globalData.cart = []
  },

  // 提交订单
  async submitOrder() {
    if (this.globalData.cart.length === 0) {
      wx.showToast({
        title: '购物车为空',
        icon: 'none'
      })
      return false
    }

    // 检查用户是否已登录
    if (!this.globalData.isLoggedIn || !this.globalData.userInfo) {
              wx.showModal({
          title: '需要登录',
          content: '下单功能需要登录后才能使用，是否现在登录？',
          confirmText: '去登录',
          cancelText: '取消',
          success: (res) => {
            if (res.confirm) {
              this.showLoginModal()
            }
          }
        })
      return false
    }

    try {
      // 验证用户信息
      if (!this.globalData.userInfo._id) {
        console.error('用户信息缺失:', this.globalData.userInfo)
        wx.showToast({
          title: '用户信息不完整，请重新登录',
          icon: 'none'
        })
        return false
      }
      
      console.log('提交订单 - 用户ID:', this.globalData.userInfo._id)
      console.log('购物车数据:', this.globalData.cart)
      
      // 计算订单总金额（积分）
      const totalPoints = this.globalData.cart.reduce((sum, item) => sum + (item.price * item.quantity), 0)
      
      // 检查用户积分是否足够
      if (this.globalData.userInfo.points < totalPoints) {
        wx.showToast({
          title: `积分不足，需要${totalPoints}积分，当前${this.globalData.userInfo.points}积分`,
          icon: 'none',
          duration: 3000
        })
        return false
      }
      
      // 构建订单数据（包含用户昵称、积分信息和家庭ID）
      const orderData = {
        userId: this.globalData.userInfo._id,
        userNickname: this.globalData.userInfo.nickname, // 添加用户昵称
        familyId: 'xiaoweichufang', // 添加固定的家庭ID
        items: [...this.globalData.cart],
        status: 'pending', // pending: 待确认, cooking: 制作中, completed: 已完成, cancelled: 已取消, rejected: 已拒绝
        totalAmount: totalPoints, // 总积分
        totalItems: this.globalData.cart.reduce((sum, item) => sum + item.quantity, 0),
        note: this.globalData.cart.find(item => item.note)?.note || ''
      }
      
      console.log('构建的订单数据:', orderData)

      // 先扣除用户积分
      const { userService } = require('./utils/cloud.js')
      const deductResult = await userService.updateUserPoints(
        this.globalData.userInfo._id, 
        totalPoints, 
        'subtract'
      )
      
      if (!deductResult.success) {
        console.error('扣除积分失败:', deductResult.error)
        wx.showToast({
          title: '积分扣除失败',
          icon: 'error'
        })
        return false
      }
      
      // 更新本地用户积分
      this.globalData.userInfo.points -= totalPoints
      
      // 先添加到本地数据
      const order = {
        id: Date.now(),
        ...orderData,
        createTime: new Date().toLocaleString()
      }

      this.globalData.orders.unshift(order)
      this.clearCart()
      
      // 同步到云数据库
      const { orderService } = require('./utils/cloud.js')
      const result = await orderService.createOrder(orderData)
      
      if (result.success) {
        console.log('订单已同步到云数据库')
        // 更新本地订单的云数据库ID
        order._id = result.data._id
        
        // 通知首页刷新订单统计
        this.globalData.needRefreshOrderStats = true
        
        wx.showToast({
          title: `订单提交成功，已扣除${totalPoints}积分`,
          icon: 'success',
          duration: 2000
        })
        
        return order
      } else {
        console.error('同步订单到云数据库失败:', result.error)
        // 如果同步失败，回滚本地数据和积分
        this.globalData.orders.shift()
        this.globalData.cart = [...orderData.items] // 恢复购物车
        
        // 恢复用户积分
        const restoreResult = await userService.updateUserPoints(
          this.globalData.userInfo._id, 
          totalPoints, 
          'add'
        )
        if (restoreResult.success) {
          this.globalData.userInfo.points += totalPoints
        }
        
        wx.showToast({
          title: '订单提交失败',
          icon: 'error'
        })
        
        return false
      }
    } catch (error) {
      console.error('提交订单失败:', error)
      wx.showToast({
        title: '订单提交失败',
        icon: 'error'
      })
      return false
    }
  },

  // 恢复家庭信息
  async restoreFamilyInfo(userInfo) {
    try {
      console.log('开始恢复家庭信息...')
      
      // 优先从本地存储恢复
      const familyInfo = wx.getStorageSync('familyInfo')
      console.log('本地存储 - familyInfo:', familyInfo)
      
      if (familyInfo && familyInfo._id) {
        // 本地有家庭信息，直接使用
        this.globalData.familyInfo = familyInfo
        console.log('本地家庭信息恢复成功:', familyInfo._id)
      } else {
        // 本地没有家庭信息，使用固定家庭ID
        const fixedFamilyId = 'xiaoweichufang'
        console.log('使用固定家庭ID:', fixedFamilyId)
        
        try {
          const { familyService } = require('./utils/cloud.js')
          const familyResult = await familyService.getFamilyById(fixedFamilyId)
          
          if (familyResult.success && familyResult.data) {
            this.globalData.familyInfo = familyResult.data
            wx.setStorageSync('familyInfo', familyResult.data)
            console.log('从云数据库恢复家庭信息成功:', familyResult.data._id)
          } else {
            // 家庭不存在，创建默认家庭信息
            this.createDefaultFamilyInfo(fixedFamilyId)
          }
        } catch (error) {
          console.error('从云数据库恢复家庭信息失败:', error)
          this.createDefaultFamilyInfo(fixedFamilyId)
        }
      }
      
      console.log('全局数据 - familyInfo._id:', this.globalData.familyInfo?._id)
    } catch (error) {
      console.error('恢复家庭信息失败:', error)
    }
  },

  // 处理微信登录（供登录弹框调用）
  async handleWxLogin(wxUserInfo, code, customNickname) {
    try {
      console.log('开始处理微信登录...')
      console.log('微信用户信息:', wxUserInfo)
      console.log('微信登录code:', code)
      console.log('自定义昵称:', customNickname)
      
      const { userService } = require('./utils/cloud.js')
      
      // 注意：这里需要先通过云函数获取真实的openid
      // 因为wx.login()返回的code是临时的，不能直接作为openid使用
      console.log('需要通过云函数获取真实openid...')
      
      // 调用云函数获取openid
      const openidResult = await this.getOpenidFromCode(code)
      if (!openidResult.success) {
        console.error('获取openid失败:', openidResult.error)
        return { success: false, error: '获取用户标识失败' }
      }
      
      const realOpenid = openidResult.data.openid
      console.log('获取到真实openid:', realOpenid)
      
      // 先尝试通过_openid查找已存在的用户
      console.log('检查用户是否已存在...')
      console.log('使用_openid查询:', realOpenid)
      console.log('注意：_openid是微信云开发自动生成的字段，用于用户身份识别')
      
      const existingUserResult = await userService.getUserByOpenid(realOpenid)
      console.log('查询结果:', existingUserResult)
      
      if (existingUserResult.success && existingUserResult.data) {
        console.log('✅ 用户已存在，直接登录:', existingUserResult.data)
        console.log('用户ID:', existingUserResult.data._id)
        console.log('用户昵称:', existingUserResult.data.nickname)
        console.log('用户积分:', existingUserResult.data.points)
        
        // 用户已存在，直接登录
        const userData = existingUserResult.data
        
        // 更新用户信息（昵称可能已更改）
        if (customNickname && customNickname !== userData.nickname) {
          console.log('更新用户昵称:', customNickname)
          const updateResult = await userService.updateUser(userData._id, {
            nickname: customNickname,
            updateTime: new Date()
          })
          
          if (updateResult.success) {
            userData.nickname = customNickname
            console.log('用户昵称更新成功')
          }
        }
        
        // 更新全局数据
        this.globalData.userInfo = userData
        this.globalData.userRole = userData.role || 'member'
        this.globalData.isLoggedIn = true
        
        // 保存到本地存储
        wx.setStorageSync('userInfo', userData)
        wx.setStorageSync('userRole', userData.role || 'member')
        wx.setStorageSync('isLoggedIn', true)
        
        // 恢复家庭信息
        await this.restoreFamilyInfo(userData)
        
        // 从云数据库加载服务数据
        await this.loadDishesFromCloud()
        
        // 从云数据库加载订单数据
        await this.loadOrdersFromCloud()
        
        // 从云数据库获取用户最新积分
        await this.loadUserPointsFromCloud()
        
        console.log('已存在用户登录完成')
        return { success: true, data: userData, isNewUser: false }
      } else {
        console.log('❌ 用户不存在，创建新用户...')
        
        // 用户不存在，创建新用户
        // 注意：创建用户时不需要手动设置_openid，系统会自动生成
        const userData = {
          nickname: customNickname || wxUserInfo.nickName,
          avatar: wxUserInfo.avatarUrl,
          role: 'member',
          points: 1000, // 默认积分
          familyId: 'xiaoweichufang'
        }
        
        console.log('新用户数据:', userData)
        
        // 调用云函数创建用户
        const createResult = await userService.createUser(userData)
        
        if (createResult.success) {
          console.log('新用户创建成功:', createResult.data)
          
          // 更新全局数据
          this.globalData.userInfo = createResult.data
          this.globalData.userRole = 'member'
          this.globalData.isLoggedIn = true
          
          // 保存到本地存储
          wx.setStorageSync('userInfo', createResult.data)
          wx.setStorageSync('userRole', 'member')
          wx.setStorageSync('isLoggedIn', true)
          
          // 恢复家庭信息
          await this.restoreFamilyInfo(createResult.data)
          
          // 从云数据库加载服务数据
          await this.loadDishesFromCloud()
          
          // 从云数据库加载订单数据
          await this.loadOrdersFromCloud()
          
          // 从云数据库获取用户最新积分
          await this.loadUserPointsFromCloud()
          
          console.log('新用户登录完成')
          return { success: true, data: createResult.data, isNewUser: true }
        } else {
          console.error('新用户创建失败:', createResult.error)
          return { success: false, error: createResult.error }
        }
      }
    } catch (error) {
      console.error('处理微信登录失败:', error)
      return { success: false, error: error.message }
    }
  },

  // 通过code获取openid的云函数调用
  async getOpenidFromCode(code) {
    try {
      console.log('调用云函数获取openid，code:', code)
      
      // 调用云函数获取openid
      const result = await wx.cloud.callFunction({
        name: 'getOpenId',
        data: { code: code }
      })
      
      console.log('云函数返回结果:', result)
      
      if (result.result && result.result.openid) {
        return { success: true, data: { openid: result.result.openid } }
      } else {
        console.error('云函数返回数据格式错误:', result)
        return { success: false, error: '云函数返回数据格式错误' }
      }
    } catch (error) {
      console.error('调用云函数失败:', error)
      return { success: false, error: error.message }
    }
  },

  // 全局显示登录弹框
  showLoginModal() {
    // 直接显示全局登录弹框，无需跳转页面
    this.globalData.showGlobalLoginModal = true
    
    // 通知所有页面显示登录弹框
    if (this.globalData.eventBus) {
      this.globalData.eventBus.emit('showGlobalLoginModal')
    }
  },

  // ===== TabBar动态图标管理 =====
  
  // 加载TabBar图标配置
  async loadTabBarIcons() {
    try {
      console.log('开始加载TabBar图标配置...')
      
      // 调用云函数获取TabBar图标配置
      const result = await wx.cloud.callFunction({
        name: 'getTabBarIcons'
      })
      
      console.log('TabBar图标配置加载结果:', result)
      
      if (result.result && result.result.success && result.result.data) {
        // 成功获取到自定义图标配置
        const customIcons = result.result.data
        console.log('获取到自定义TabBar图标:', customIcons)
        
        // 缓存到本地存储
        wx.setStorageSync('tabBarIcons', customIcons)
        
        // 应用到TabBar
        await this.setDynamicTabBarIcons(customIcons)
        
        console.log('TabBar图标更新完成')
        return { success: true, data: customIcons }
      } else {
        console.log('暂无自定义TabBar图标，使用默认配置')
        // 清除本地缓存的图标配置
        wx.removeStorageSync('tabBarIcons')
        
        // 主动应用默认图标（用于重置后恢复默认状态）
        await this.setDynamicTabBarIcons({})
        
        return { success: true, data: {} }
      }
      
    } catch (error) {
      console.error('加载TabBar图标配置失败:', error)
      
      // 尝试使用本地缓存
      const cachedIcons = wx.getStorageSync('tabBarIcons')
      if (cachedIcons && Object.keys(cachedIcons).length > 0) {
        console.log('使用本地缓存的TabBar图标:', cachedIcons)
        await this.setDynamicTabBarIcons(cachedIcons)
        return { success: true, data: cachedIcons }
      }
      
      // 云端和本地都失败，使用默认图标
      console.log('使用默认TabBar图标')
      return { success: false, error: error.message }
    }
  },
  
  // 应用动态TabBar图标
  async setDynamicTabBarIcons(customIcons) {
    try {
      console.log('开始应用动态TabBar图标:', customIcons)
      
      // 检查当前是否在TabBar页面
      const pages = getCurrentPages()
      const currentPage = pages[pages.length - 1]
      const currentRoute = currentPage ? currentPage.route : ''
      
      console.log('当前页面路径:', currentRoute)
      
      // TabBar页面列表
      const tabBarPages = [
        'pages/index/index',
        'pages/dishes/dishes', 
        'pages/cart/cart',
        'pages/orders/orders',
        'pages/profile/profile'
      ]
      
      // 如果当前不在TabBar页面，则先保存配置，等待切换到TabBar页面时再更新
      if (!tabBarPages.includes(currentRoute)) {
        console.log('当前不在TabBar页面，保存配置到本地，等待切换到TabBar页面时更新')
        // 保存配置到全局数据和本地存储
        this.globalData.pendingTabBarIcons = customIcons
        wx.setStorageSync('pendingTabBarIcons', customIcons)
        return
      }
      
      // TabBar项目映射
      const tabBarItems = [
        { index: 0, type: 'home', defaultIcon: 'images/tabbar/home.png', defaultSelectedIcon: 'images/tabbar/home-active.png' },
        { index: 1, type: 'dishes', defaultIcon: 'images/tabbar/dishes.png', defaultSelectedIcon: 'images/tabbar/dishes-active.png' },
        { index: 2, type: 'cart', defaultIcon: 'images/tabbar/cart.png', defaultSelectedIcon: 'images/tabbar/cart-active.png' },
        { index: 3, type: 'orders', defaultIcon: 'images/tabbar/orders.png', defaultSelectedIcon: 'images/tabbar/orders-active.png' },
        { index: 4, type: 'profile', defaultIcon: 'images/tabbar/profile.png', defaultSelectedIcon: 'images/tabbar/profile-active.png' }
      ]
      
      // 收集需要转换的云存储URL
      const cloudUrls = []
      for (const item of tabBarItems) {
        const customIcon = customIcons[item.type]
        if (customIcon) {
          if (customIcon.normal && customIcon.normal.startsWith('cloud://')) {
            cloudUrls.push(customIcon.normal)
          }
          if (customIcon.selected && customIcon.selected.startsWith('cloud://')) {
            cloudUrls.push(customIcon.selected)
          }
        }
      }
      
      // 转换云存储URL为临时访问链接
      let tempUrlMap = {}
      if (cloudUrls.length > 0) {
        console.log('转换云存储URL为临时链接:', cloudUrls)
        try {
          const tempUrlResult = await new Promise((resolve, reject) => {
            wx.cloud.getTempFileURL({
              fileList: cloudUrls,
              success: resolve,
              fail: reject
            })
          })
          
          if (tempUrlResult.fileList) {
            for (const file of tempUrlResult.fileList) {
              if (file.status === 0) {
                tempUrlMap[file.fileID] = file.tempFileURL
                console.log(`云存储URL转换成功: ${file.fileID} -> ${file.tempFileURL}`)
              } else {
                console.error(`云存储URL转换失败: ${file.fileID}`, file.errMsg)
              }
            }
          }
        } catch (error) {
          console.error('获取云存储临时链接失败:', error)
        }
      }
      
      // 逐个更新TabBar项目
      for (const item of tabBarItems) {
        const customIcon = customIcons[item.type]
        
        // 确定要使用的图标路径
        let iconPath = item.defaultIcon
        let selectedIconPath = item.defaultSelectedIcon
        
        if (customIcon) {
          // 优化云存储URL处理逐辑
          if (customIcon.normal) {
            // 检查是否为云存储URL
            if (customIcon.normal.startsWith('cloud://')) {
              // 使用转换后的临时链接
              iconPath = tempUrlMap[customIcon.normal] || item.defaultIcon
              if (!tempUrlMap[customIcon.normal]) {
                console.warn(`云存储URL ${customIcon.normal} 转换失败，使用默认图标`)
              }
            } else if (customIcon.normal.startsWith('/') || customIcon.normal.startsWith('http')) {
              // 相对路径或HTTP(S) URL
              iconPath = customIcon.normal
            } else {
              // 只是文件名，使用默认路径
              iconPath = item.defaultIcon
            }
          }
          
          if (customIcon.selected) {
            if (customIcon.selected.startsWith('cloud://')) {
              // 使用转换后的临时链接
              selectedIconPath = tempUrlMap[customIcon.selected] || item.defaultSelectedIcon
              if (!tempUrlMap[customIcon.selected]) {
                console.warn(`云存储URL ${customIcon.selected} 转换失败，使用默认图标`)
              }
            } else if (customIcon.selected.startsWith('/') || customIcon.selected.startsWith('http')) {
              selectedIconPath = customIcon.selected
            } else {
              selectedIconPath = item.defaultSelectedIcon
            }
          }
        }
        
        console.log(`更新TabBar项目 ${item.type}:`, { iconPath, selectedIconPath })
        
        try {
          // 使用微信API更新TabBar项目
          await new Promise((resolve, reject) => {
            wx.setTabBarItem({
              index: item.index,
              iconPath: iconPath,
              selectedIconPath: selectedIconPath,
              success: () => {
                console.log(`TabBar项目 ${item.type} 更新成功`)
                resolve()
              },
              fail: (error) => {
                console.error(`TabBar项目 ${item.type} 更新失败:`, error)
                reject(error)
              }
            })
          })
        } catch (itemError) {
          console.error(`设置TabBar项目 ${item.type} 失败:`, itemError)
          // 继续处理下一个项目，不中断整个流程
        }
      }
      
      console.log('所有TabBar项目更新完成')
      
      // 清除待处理的配置
      this.globalData.pendingTabBarIcons = null
      wx.removeStorageSync('pendingTabBarIcons')
      
    } catch (error) {
      console.error('应用动态TabBar图标失败:', error)
      throw error
    }
  },
  
  // 刷新TabBar图标（供外部调用）
  async refreshTabBarIcons() {
    console.log('刷新TabBar图标...')
    const result = await this.loadTabBarIcons()
    
    // 更新校验值，确保下次定时检查时不会认为是新变化
    if (result.success && result.data) {
      this.globalData.lastTabBarChecksum = this.calculateTabBarChecksum(result.data)
    }
    
    return result
  },
  
  // 检查并应用等待中的TabBar图标配置（在TabBar页面调用）
  async applyPendingTabBarIcons() {
    try {
      // 检查是否有等待中的配置
      const pendingIcons = this.globalData.pendingTabBarIcons || wx.getStorageSync('pendingTabBarIcons')
      
      if (pendingIcons && Object.keys(pendingIcons).length > 0) {
        console.log('发现等待中的TabBar图标配置，开始应用:', pendingIcons)
        
        // 应用配置
        await this.setDynamicTabBarIcons(pendingIcons)
        
        console.log('TabBar图标配置应用成功')
      }
    } catch (error) {
      console.error('应用等待中的TabBar图标配置失败:', error)
    }
  },
  
  // 通用的TabBar页面初始化方法（供所有TabBar页面在onShow中调用）
  initTabBarPage() {
    // 延迟执行，确保页面已完全加载
    setTimeout(() => {
      this.applyPendingTabBarIcons()
    }, 100)
    
    // 另外再尝试刷新当前的TabBar图标配置
    setTimeout(() => {
      const cachedIcons = wx.getStorageSync('tabBarIcons')
      if (cachedIcons && Object.keys(cachedIcons).length > 0) {
        console.log('发现缓存的TabBar图标配置，尝试重新应用:', cachedIcons)
        this.setDynamicTabBarIcons(cachedIcons)
      }
    }, 500)
  },
  
  // 在应用启动时加载TabBar图标
  async initTabBarIcons() {
    console.log('初始化TabBar图标...')
    
    // 延迟一段时间后加载，确保云开发环境已经初始化
    setTimeout(async () => {
      await this.loadTabBarIcons()
    }, 1000)
  },
  
  // 初始化TabBar图标实时更新机制
  initTabBarAutoRefresh() {
    console.log('初始化TabBar图标实时更新机制...')
    
    // 保存上次检查的参数，用于检测变化
    this.globalData.lastTabBarChecksum = null
    
    // 设置定时检查间隔（30秒）
    const refreshInterval = 30 * 1000
    
    // 延迟5秒后开始第一次检查，给应用初始化留出时间
    setTimeout(() => {
      this.startTabBarAutoRefresh(refreshInterval)
    }, 5000)
  },
  
  // 开始定时检查TabBar更新
  startTabBarAutoRefresh(interval) {
    console.log(`开始 TabBar 定时检查，间隔: ${interval / 1000}秒`)
    
    // 清除之前的定时器
    if (this.globalData.tabBarRefreshTimer) {
      clearInterval(this.globalData.tabBarRefreshTimer)
    }
    
    // 设置新的定时器
    this.globalData.tabBarRefreshTimer = setInterval(async () => {
      await this.checkTabBarIconUpdates()
    }, interval)
  },
  
  // 检查TabBar图标是否有更新
  async checkTabBarIconUpdates() {
    try {
      console.log('检查 TabBar 图标更新...')
      
      // 获取最新的TabBar配置
      const result = await wx.cloud.callFunction({
        name: 'getTabBarIcons'
      })
      
      if (result.result && result.result.success) {
        const newIcons = result.result.data || {}
        
        // 计算新配置的校验值
        const newChecksum = this.calculateTabBarChecksum(newIcons)
        
        // 如果校验值发生变化，说明配置有更新
        if (this.globalData.lastTabBarChecksum !== null && 
            this.globalData.lastTabBarChecksum !== newChecksum) {
          
          console.log('TabBar 配置发生变化，开始更新...')
          console.log('旧校验值:', this.globalData.lastTabBarChecksum)
          console.log('新校验值:', newChecksum)
          
          // 更新本地缓存
          wx.setStorageSync('tabBarIcons', newIcons)
          
          // 应用新的TabBar配置
          await this.setDynamicTabBarIcons(newIcons)
          
          console.log('TabBar 图标实时更新完成')
        } else {
          console.log('TabBar 配置无变化')
        }
        
        // 更新校验值
        this.globalData.lastTabBarChecksum = newChecksum
        
      } else {
        console.log('获取 TabBar 配置失败或无配置')
      }
      
    } catch (error) {
      console.error('TabBar 更新检查失败:', error)
    }
  },
  
  // 计算TabBar配置的校验值
  calculateTabBarChecksum(icons) {
    if (!icons || typeof icons !== 'object') {
      return 'empty'
    }
    
    // 将配置对象转为排序后的JSON字符串
    const sortedKeys = Object.keys(icons).sort()
    const sortedConfig = {}
    
    for (const key of sortedKeys) {
      sortedConfig[key] = icons[key]
    }
    
    const configStr = JSON.stringify(sortedConfig)
    
    // 简单的字符串哈希算法
    let hash = 0
    for (let i = 0; i < configStr.length; i++) {
      const char = configStr.charCodeAt(i)
      hash = ((hash << 5) - hash) + char
      hash = hash & hash // 转为32位整数
    }
    
    return hash.toString()
  },
  
  // 停止TabBar自动刷新（用于应用隐藏或销毁时）
  stopTabBarAutoRefresh() {
    if (this.globalData.tabBarRefreshTimer) {
      clearInterval(this.globalData.tabBarRefreshTimer)
      this.globalData.tabBarRefreshTimer = null
      console.log('TabBar 自动刷新已停止')
    }
  }
}) 